package com.melody.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.melody.entry.*;
import com.melody.mapper.MusicInfoMapper;
import com.melody.mapper.UserInfoMapper;
import com.melody.model.vo.PlaylistInfoVo;
import com.melody.service.PlaylistInfoService;
import com.melody.mapper.PlaylistInfoMapper;
import com.melody.utils.ThreadLocalUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * PlaylistInfoServiceImpl类实现了PlaylistInfoService接口，负责对歌单信息表（playlist_info）进行数据库操作。
 *
 * @author zxz
 * @description 针对表【playlist_info(歌单信息表)】的数据库操作Service实现
 * @createDate 2025-05-09 10:31:17
 */
@Service
public class PlaylistInfoServiceImpl extends ServiceImpl<PlaylistInfoMapper, PlaylistInfo> implements PlaylistInfoService {

    @Autowired
    private PlaylistInfoMapper playlistInfoMapper;
    @Autowired
    private MusicInfoMapper musicInfoMapper;
    @Autowired
    private UserInfoMapper userInfoMapper;

    /**
     * 创建一个新的歌单。
     *
     * @param playlistInfo 歌单信息
     * @return Result<PlaylistInfo> 创建结果，包含创建成功的歌单信息或错误信息
     */
    @Override
    public Result<PlaylistInfo> createPlaylist(PlaylistInfo playlistInfo) {
        Map<String, Object> userInfo = ThreadLocalUtil.get(); // 获取当前用户信息

        // 调用Mapper层方法插入歌单信息
        Integer userId = (Integer) userInfo.get("userId"); // 获取用户ID
        playlistInfo.setUserId(userId); // 设置歌单的用户ID
        playlistInfo.setType(0); // 设置歌单类型
        playlistInfo.setCollectionVolume(0); // 设置收藏量
        playlistInfoMapper.insertPlaylist(playlistInfo); // 插入歌单信息

        QueryWrapper<PlaylistInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("list_id", playlistInfo.getListId()); // 假设list_id是自增主键

        PlaylistInfo createdPlaylist = playlistInfoMapper.selectOne(queryWrapper); // 查询刚刚插入的歌单
        if (createdPlaylist != null) {
            return Result.success(createdPlaylist); // 返回创建成功的歌单信息
        } else {
            return Result.error("创建歌单失败"); // 返回错误信息
        }
    }

    /**
     * 根据用户ID分页获取用户收藏的歌单。
     *
     * @param userId 用户ID
     * @param page   页码
     * @param limit  每页记录数
     * @return List<PlaylistInfo> 用户收藏的歌单列表
     */
    @Override
    public List<PlaylistInfo> getPlaylistsByUserId(Integer userId, Integer page, Integer limit) {
        int offset = (page - 1) * limit; // 计算偏移量
        Map<String, Object> params = new HashMap<>();
        params.put("userId", userId); // 设置用户ID参数
        params.put("limit", limit); // 设置每页记录数参数
        params.put("offset", offset); // 设置偏移量参数
        return playlistInfoMapper.selectPlaylistsByUserId(params); // 查询歌单列表
    }

    /**
     * 更新歌单信息。
     *
     * @param playlistInfo 歌单信息
     * @return PlaylistInfo 更新后的歌单信息，如果更新失败则返回null
     */
    @Override
    public PlaylistInfo updatePlaylistInfo(PlaylistInfo playlistInfo) {
        Map<String, Object> userInfo = ThreadLocalUtil.get(); // 获取当前用户信息
        Integer userId = (Integer) userInfo.get("userId"); // 获取用户ID
        playlistInfo.setUserId(userId); // 设置歌单的用户ID
        playlistInfoMapper.updatePlaylistInfo(playlistInfo); // 更新歌单信息

        QueryWrapper<PlaylistInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("list_id", playlistInfo.getListId()); // 假设list_id是自增主键

        PlaylistInfo updatedPlaylist = playlistInfoMapper.selectOne(queryWrapper); // 查询刚刚更新的歌单
        if (updatedPlaylist != null) {
            return updatedPlaylist; // 返回更新后的歌单信息
        } else {
            return null; // 返回null表示更新失败
        }
    }

    /**
     * 删除指定ID的歌单。
     *
     * @param id 歌单ID
     * @return PlaylistInfo 删除的歌单信息，如果删除失败则返回null
     */
    @Override
    public PlaylistInfo deletePlaylistInfo(Long id) {
        // 构建查询条件
        QueryWrapper<PlaylistInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("list_id", id); // 指定歌单ID

        // 先根据条件查询记录
        PlaylistInfo playlistInfo = playlistInfoMapper.selectOne(queryWrapper); // 查询歌单
        if (playlistInfo == null) {
            // 如果没有找到记录，返回null
            return null;
        }

        // 删除记录
        int deleteCount = playlistInfoMapper.delete(queryWrapper); // 执行删除操作
        if (deleteCount > 0) {
            // 如果删除成功，返回删除的歌单信息
            return playlistInfo;
        } else {
            // 如果删除失败，返回null
            return null;
        }
    }

    /**
     * 获取指定ID的歌单详情。
     *
     * @param id 歌单ID
     * @return PlaylistInfo 歌单详情，如果未找到则返回null
     */
    @Override
    public PlaylistInfo getPlaylistDetails(Long id) {
        // 构建查询条件
        QueryWrapper<PlaylistInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("list_id", id); // 指定歌单ID

        // 先根据条件查询记录
        PlaylistInfo playlistInfo = playlistInfoMapper.selectOne(queryWrapper); // 查询歌单
        if (playlistInfo == null) {
            // 如果没有找到记录，返回null
            return null;
        } else {
            return playlistInfo; // 返回歌单详情
        }
    }

    /**
     * 根据标签ID获取歌单列表。
     *
     * @param labelId 标签ID
     * @param limit   查询条数限制
     * @return List<PlaylistInfo> 歌单列表
     */
    @Override
    public List<PlaylistInfo> getPlaylistsByLabelId(Integer labelId, Integer limit) {
        // 构建查询条件
        QueryWrapper<PlaylistInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("label_id", labelId) // 指定标签ID
                .last("LIMIT " + limit); // 限制查询条数

        // 查询记录
        return playlistInfoMapper.selectList(queryWrapper); // 查询歌单列表
    }

    /**
     * 根据歌单id获取歌单详细信息（歌单+歌曲列表）
     *
     * @param listId
     * @return
     */
    @Override
    public PlaylistInfoVo getSongListInfoById(Integer listId) {
        //联合查询
        PlaylistInfoVo songListInfo = playlistInfoMapper.getSongListInfoById(listId);
        if (songListInfo != null) {
            //联合查询成功
            return playlistInfoMapper.getSongListInfoById(listId);
        }
//        联合查询失败返回，只返回歌单信息
        //1.构造PlaylistInfoVo
        PlaylistInfoVo playlistInfoVo = new PlaylistInfoVo();
        //2.获取歌单详情
        LambdaQueryWrapper<PlaylistInfo> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(PlaylistInfo::getListId, listId)
                .eq(PlaylistInfo::getIsDelete, 0);
        PlaylistInfo playlistInfo = playlistInfoMapper.selectOne(queryWrapper);
        if (playlistInfo == null) {
            return playlistInfoVo;
        } else {
            BeanUtil.copyProperties(playlistInfo, playlistInfoVo);
            //3.获取用户详情
            LambdaQueryWrapper<UserInfo> queryWrapper1 = new LambdaQueryWrapper<>();
            queryWrapper1.eq(UserInfo::getUserId, playlistInfo.getUserId());
            UserInfo userInfo = userInfoMapper.selectOne(queryWrapper1);
            playlistInfoVo.setUserImg(userInfo.getUserImg());
            playlistInfoVo.setPlaylistCreatorName(userInfo.getUserName());
            return playlistInfoVo;
        }
    }


    @Override
    public List<PlaylistInfo> getRandomPlaylistInfo(int page, int limit) {
        // 计算分页的偏移量，用于从数据库中获取指定范围的数据
        // 偏移量 = (当前页码 - 1) * 每页显示的数量
        int offset = (page - 1) * limit;
        // 调用Mapper层方法，根据每页显示数量和偏移量获取随机歌单信息
        // 这里使用分页逻辑来限制返回的歌单数量
        return playlistInfoMapper.getRandomPlaylistInfo(limit, offset);
    }

    @Override
    public List<PlaylistInfo> getRandomPlaylistInfos(int limit) {
        // 调用Mapper层方法，根据指定的数量获取随机歌单信息
        // 这里不涉及分页逻辑，直接返回指定数量的随机歌单
        return playlistInfoMapper.getRandomPlaylistInfos(limit);
    }

    @Override
    public List<MusicInfo> getFavoriteByUserId(Integer userID) {
        return playlistInfoMapper.getFavoriteByUserId(userID);
    }

    /**
     * 根据标签id分页查询歌单列表
     * */
    @Override
    public List<PlaylistInfo> getPlaylistListByLabelId(Integer labelId, Integer pageNum, Integer pageSize) {
        // 构建查询条件
        QueryWrapper<PlaylistInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("label_id", labelId)
                .orderByDesc("collection_volume")
                .last("LIMIT " + (pageNum - 1) * pageSize + ", " + pageSize);

        // 查询记录
        return playlistInfoMapper.selectList(queryWrapper);
    }
}